package com.project.jdbc.utils;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

import org.apache.commons.lang3.StringUtils;
import org.joda.time.DateTime;
import org.joda.time.Days;
import org.joda.time.Hours;
import org.joda.time.Minutes;
import org.joda.time.Months;
import org.joda.time.Weeks;
import org.joda.time.Years;

public class DateUtils {
	private static String DATETIME_FORMAT = "yyyy-MM-dd HH:mm";
	private static String DATE_FORMAT = "yyyy-MM-dd";

	/**
	 * Get the previous time, from how many days to now.
	 * 
	 * @param days
	 *            How many days.
	 * @return The new previous time.
	 */
	public static Date previous(int days) {
		return new Date(System.currentTimeMillis() - days * 3600000L * 24L);
	}

	/**
	 * Convert date and time to string like "yyyy-MM-dd HH:mm".
	 */
	public static String formatDateTime(Date d) {
		return new SimpleDateFormat(DATETIME_FORMAT).format(d);
	}

	/**
	 * Convert date and time to string like "yyyy-MM-dd HH:mm".
	 */
	public static String formatDateTime(long d) {
		return new SimpleDateFormat(DATETIME_FORMAT).format(d);
	}

	/**
	 * Parse date like "yyyy-MM-dd".
	 */
	public static Date parseDate(String d) {
		try {
			return new SimpleDateFormat(DATE_FORMAT).parse(d);
		} catch (Exception e) {
		}
		return null;
	}

	/**
	 * Parse date and time like "yyyy-MM-dd hh:mm".
	 */
	public static Date parseDateTime(String dt) {
		try {
			return new SimpleDateFormat(DATETIME_FORMAT).parse(dt);
		} catch (Exception e) {
		}
		return null;
	}

	/** 日期 */
	public final static String DEFAILT_DATE_PATTERN = "yyyy-MM-dd";
	/** 日期时间 */
	public final static String DEFAILT_DATE_TIME_PATTERN = "yyyy-MM-dd HH:mm:ss";
	/** 时间 */
	public final static String DEFAULT_TIME_PATTERN = "HH:mm:ss";
	/**
	 * 每天的毫秒数
	 */
	public final static long MILLIS_IN_DAY = 1000 * 60 * 60 * 24;

	/**
	 * 转换日期字符串得到指定格式的日期类型
	 * 
	 * @param formatString
	 *            需要转换的格式字符串
	 * @param targetDate
	 *            需要转换的时间
	 * @return
	 * @throws ParseException
	 */
	public static final Date convertString2Date(String formatString,
			String targetDate) throws ParseException {
		if (StringUtils.isBlank(targetDate))
			return null;
		SimpleDateFormat format = null;
		Date result = null;
		format = new SimpleDateFormat(formatString);
		try {
			result = format.parse(targetDate);
		} catch (ParseException pe) {
			throw new ParseException(pe.getMessage(), pe.getErrorOffset());
		}
		return result;
	}

	public static final Date convertString2Date(String[] formatString,
			String targetDate) throws ParseException {
		if (StringUtils.isBlank(targetDate)) {
			return null;
		}
		SimpleDateFormat format = null;
		Date result = null;
		String errorMessage = null;
		Integer errorOffset = null;
		for (String dateFormat : formatString) {
			try {
				format = new SimpleDateFormat(dateFormat);
				result = format.parse(targetDate);
			} catch (ParseException pe) {
				result = null;
				errorMessage = pe.getMessage();
				errorOffset = pe.getErrorOffset();
			} finally {
				if (result != null && result.getTime() > 1) {
					break;
				}
			}
		}
		if (result == null) {
			throw new ParseException(errorMessage, errorOffset);
		}
		return result;
	}

	/**
	 * 转换字符串得到默认格式的日期类型
	 * 
	 * @param strDate
	 * @return
	 * @throws ParseException
	 */
	public static Date convertString2Date(String strDate) throws ParseException {
		Date result = null;
		try {
			result = convertString2Date(DEFAILT_DATE_PATTERN, strDate);
		} catch (ParseException pe) {
			throw new ParseException(pe.getMessage(), pe.getErrorOffset());
		}
		return result;
	}

	/**
	 * 转换日期得到指定格式的日期字符串
	 * 
	 * @param formatString
	 *            需要把目标日期格式化什么样子的格式。例如,yyyy-MM-dd HH:mm:ss
	 * @param targetDate
	 *            目标日期
	 * @return
	 */
	public static String convertDate2String(String formatString, Date targetDate) {
		SimpleDateFormat format = null;
		String result = null;
		if (targetDate != null) {
			format = new SimpleDateFormat(formatString);
			result = format.format(targetDate);
		} else {
			return null;
		}
		return result;
	}

	/**
	 * 转换日期,得到默认日期格式字符串
	 * 
	 * @param targetDate
	 * @return
	 */
	public static String convertDate2String(Date targetDate) {
		return convertDate2String(DEFAILT_DATE_PATTERN, targetDate);
	}

	/**
	 * 比较日期大小
	 * 
	 * @param src
	 * @param src
	 * @return int; 1:DATE1>DATE2;
	 */
	public static int compare_date(Date src, Date src1) {

		String date1 = convertDate2String(DEFAILT_DATE_TIME_PATTERN, src);
		String date2 = convertDate2String(DEFAILT_DATE_TIME_PATTERN, src1);
		DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		try {
			Date dt1 = df.parse(date1);
			Date dt2 = df.parse(date2);
			if (dt1.getTime() > dt2.getTime()) {
				return 1;
			} else if (dt1.getTime() < dt2.getTime()) {
				return -1;
			} else {
				return 0;
			}
		} catch (Exception exception) {
			exception.printStackTrace();
		}
		return 0;
	}

	/**
	 * 日期比较
	 * 
	 * 判断时间date1是否在时间date2之前 <br/>
	 * 时间格式 2005-4-21 16:16:34 <br/>
	 * 添加人：胡建国
	 * 
	 * @param targetDate
	 * @return
	 */
	public static boolean isDateBefore(String date1, String date2) {
		try {
			DateFormat df = DateFormat.getDateTimeInstance();
			return df.parse(date1).before(df.parse(date2));
		} catch (ParseException e) {
			return false;
		}
	}

	/**
	 * 日期比较
	 * 
	 * 判断当前时间是否在时间date2之前 <br/>
	 * 时间格式 2005-4-21 16:16:34 <br/>
	 * 添加人：胡建国
	 * 
	 * @param targetDate
	 * @return
	 */
	public static boolean isDateBefore(String date2) {
		if (date2 == null) {
			return false;
		}
		try {
			Date date1 = new Date();
			DateFormat df = DateFormat.getDateTimeInstance();
			return date1.before(df.parse(date2));
		} catch (ParseException e) {
			return false;
		}
	}

	/**
	 * 比较当前时间与时间date2的天相等 时间格式 2008-11-25 16:30:10 如:当前时间是2008-11-25
	 * 16:30:10与传入时间2008-11-25 15:31:20 相比较,返回true即相等
	 * 
	 * @param date1
	 * @param date2
	 * @return boolean; true:相等
	 * @author zhangjl
	 */
	public static boolean equalDate(String date2) {
		try {
			String date1 = convertDate2String(DEFAILT_DATE_TIME_PATTERN,
					new Date());
			date1.equals(date2);
			Date d1 = convertString2Date(DEFAILT_DATE_PATTERN, date1);
			Date d2 = convertString2Date(DEFAILT_DATE_PATTERN, date2);
			return d1.equals(d2);
		} catch (ParseException e) {
			System.out.println(e.getMessage());
			return false;
		}
	}

	/**
	 * 比较时间date1与时间date2的天相等 时间格式 2008-11-25 16:30:10
	 * 
	 * @param date1
	 * @param date2
	 * @return boolean; true:相等
	 * @author zhangjl
	 */
	public static boolean equalDate(String date1, String date2) {
		try {

			Date d1 = convertString2Date(DEFAILT_DATE_PATTERN, date1);
			Date d2 = convertString2Date(DEFAILT_DATE_PATTERN, date2);

			return d1.equals(d2);
		} catch (ParseException e) {
			return false;
		}
	}

	/**
	 * 比较时间date1是否在时间date2之前 时间格式 2008-11-25 16:30:10
	 * 
	 * @param date1
	 * @param date2
	 * @return boolean; true:在date2之前
	 * @author 胡建国
	 */
	public static boolean beforeDate(String date1, String date2) {
		try {
			Date d1 = convertString2Date(DEFAILT_DATE_PATTERN, date1);
			Date d2 = convertString2Date(DEFAILT_DATE_PATTERN, date2);
			return d1.before(d2);
		} catch (ParseException e) {
			return false;
		}
	}

	/**
	 * 获取上个月开始时间
	 * 
	 * @param currentDate
	 *            当前时间
	 * @return 上个月的第一天
	 */
	public static Date getBoferBeginDate(Calendar currentDate) {
		Calendar result = Calendar.getInstance();
		result.set(currentDate.get(Calendar.YEAR),
				(currentDate.get(Calendar.MONTH)) - 1,
				result.getActualMinimum(Calendar.DATE), 0, 0, 0);
		return result.getTime();
	}

	/**
	 * 获取指定月份的第一天
	 * 
	 * @param currentDate
	 * @return
	 */
	public static Date getBeginDate(Calendar currentDate) {
		Calendar result = Calendar.getInstance();
		result.set(currentDate.get(Calendar.YEAR),
				(currentDate.get(Calendar.MONTH)),
				result.getActualMinimum(Calendar.DATE));
		return result.getTime();
	}

	/**
	 * 获取上个月结束时间
	 * 
	 * @param currentDate
	 *            当前时间
	 * @return 上个月最后一天
	 */
	public static Date getBoferEndDate(Calendar currentDate) {
		Calendar result = currentDate;
		// result.set(currentDate.get(Calendar.YEAR), currentDate
		// .get(Calendar.MONTH) - 1);
		result.set(Calendar.DATE, 1);
		result.add(Calendar.DATE, -1);
		return result.getTime();
	}

	/**
	 * 获取两个时间的时间间隔
	 * 
	 * @param beginDate
	 *            开始时间
	 * @param endDate
	 *            结束时间
	 * @return
	 */
	public static int getDaysBetween(Calendar beginDate, Calendar endDate) {
		if (beginDate.after(endDate)) {
			Calendar swap = beginDate;
			beginDate = endDate;
			endDate = swap;
		}
		int days = endDate.get(Calendar.DAY_OF_YEAR)
				- beginDate.get(Calendar.DAY_OF_YEAR) + 1;
		int year = endDate.get(Calendar.YEAR);
		if (beginDate.get(Calendar.YEAR) != year) {
			beginDate = (Calendar) beginDate.clone();
			do {
				days += beginDate.getActualMaximum(Calendar.DAY_OF_YEAR);
				beginDate.add(Calendar.YEAR, 1);
			} while (beginDate.get(Calendar.YEAR) != year);
		}
		return days;
	}

	/**
	 * 获取两个时间的时间间隔(月份)
	 * 
	 * @param beginDate
	 *            开始时间
	 * @param endDate
	 *            结束时间
	 * @return
	 */
	public static int getMonthsBetween(Date beginDate, Date endDate) {
		if (beginDate.after(endDate)) {
			Date swap = beginDate;
			beginDate = endDate;
			endDate = swap;
		}
		int months = endDate.getMonth() - beginDate.getMonth();
		int years = endDate.getYear() - beginDate.getYear();

		months += years * 12;

		return months;
	}

	/**
	 * 获取两个时间内的工作日
	 * 
	 * @param beginDate
	 *            开始时间
	 * @param endDate
	 *            结束时间
	 * @return
	 */
	public static int getWorkingDay(Calendar beginDate, Calendar endDate) {
		int result = -1;
		if (beginDate.after(endDate)) {
			Calendar swap = beginDate;
			beginDate = endDate;
			endDate = swap;
		}
		int charge_start_date = 0;
		int charge_end_date = 0;
		int stmp;
		int etmp;
		stmp = 7 - beginDate.get(Calendar.DAY_OF_WEEK);
		etmp = 7 - endDate.get(Calendar.DAY_OF_WEEK);
		if (stmp != 0 && stmp != 6) {
			charge_start_date = stmp - 1;
		}
		if (etmp != 0 && etmp != 6) {
			charge_end_date = etmp - 1;
		}
		result = (getDaysBetween(getNextMonday(beginDate),
				getNextMonday(endDate)) / 7)
				* 5
				+ charge_start_date
				- charge_end_date;
		return result;
	}

	/**
	 * 根据当前给定的日期获取当前天是星期几(中国版的)
	 * 
	 * @param date
	 *            任意时间
	 * @return
	 */
	public static String getChineseWeek(Calendar date) {
		final String dayNames[] = { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五",
				"星期六" };
		int dayOfWeek = date.get(Calendar.DAY_OF_WEEK);
		return dayNames[dayOfWeek - 1];

	}

	/**
	 * 获得日期的下一个星期一的日期
	 * 
	 * @param date
	 *            任意时间
	 * @return
	 */
	public static Calendar getNextMonday(Calendar date) {
		Calendar result = null;
		result = date;
		do {
			result = (Calendar) result.clone();
			result.add(Calendar.DATE, 1);
		} while (result.get(Calendar.DAY_OF_WEEK) != 2);
		return result;
	}

	/**
	 * 获取两个日期之间的休息时间
	 * 
	 * @param beginDate
	 *            开始时间
	 * @param endDate
	 *            结束时间
	 * @return
	 */
	public static int getHolidays(Calendar beginDate, Calendar endDate) {
		return getDaysBetween(beginDate, endDate)
				- getWorkingDay(beginDate, endDate);

	}

	public static boolean isDateEnable(Date beginDate, Date endDate,
			Date currentDate) {
		// 开始日期
		long beginDateLong = beginDate.getTime();
		// 结束日期
		long endDateLong = endDate.getTime();
		// 当前日期
		long currentDateLong = currentDate.getTime();
		if (currentDateLong >= beginDateLong && currentDateLong <= endDateLong) {
			return Boolean.TRUE;
		}
		return Boolean.FALSE;
	}

	/**
	 * 获取当前月份的第一天
	 * 
	 * @param currtenDate
	 *            当前时间
	 * @return
	 */
	public static Date getMinDate(Calendar currentDate) {
		Calendar result = Calendar.getInstance();
		result.set(currentDate.get(Calendar.YEAR),
				currentDate.get(Calendar.MONTH),
				currentDate.getActualMinimum(Calendar.DATE));
		return result.getTime();
	}

	public static Calendar getDate(int year, int month, int date) {
		Calendar calendar = Calendar.getInstance();
		calendar.set(year, month, date);
		return calendar;
	}

	public static Calendar getDate(int year, int month) {
		return getDate(year, month, 0);
	}

	public static Date getCountMinDate(int year, int month) {
		Calendar calendar = Calendar.getInstance();
		calendar.set(year, month - 1, calendar.getActualMinimum(Calendar.DATE));
		return calendar.getTime();
	}

	public static Date getCountMaxDate(int year, int month) {
		Calendar calendar = Calendar.getInstance();
		calendar.set(Calendar.YEAR, year);
		calendar.set(Calendar.MONTH, month);
		Calendar calendar2 = Calendar.getInstance();
		calendar2.set(calendar.get(Calendar.YEAR),
				calendar.get(Calendar.MONTH), 0);
		return calendar2.getTime();
	}

	/**
	 * 获取当前月份的第一天
	 * 
	 * @param currtenDate
	 *            当前时间
	 * @return
	 */
	public static Date getMinDate() {
		Calendar currentDate = Calendar.getInstance();
		return getMinDate(currentDate);
	}

	/**
	 * 获取当前月分的最大天数
	 * 
	 * @param currentDate
	 *            当前时间
	 * @return
	 */
	public static Date getMaxDate(Calendar currentDate) {
		Calendar result = Calendar.getInstance();
		result.set(currentDate.get(Calendar.YEAR),
				currentDate.get(Calendar.MONTH),
				currentDate.getActualMaximum(Calendar.DATE));
		return result.getTime();
	}

	/**
	 * 获取当前月分的最大天数
	 * 
	 * @param currentDate
	 *            当前时间
	 * @return
	 */
	public static Date getMaxDate() {
		Calendar currentDate = Calendar.getInstance();
		return getMaxDate(currentDate);
	}

	/**
	 * 获取今天最大的时间
	 * 
	 * @return
	 */
	public static String getMaxDateTimeForToDay() {
		Calendar calendar = Calendar.getInstance();
		calendar.set(Calendar.HOUR_OF_DAY,
				calendar.getMaximum(Calendar.HOUR_OF_DAY));
		calendar.set(Calendar.MINUTE, calendar.getMaximum(Calendar.MINUTE));
		calendar.set(Calendar.SECOND, calendar.getMaximum(Calendar.SECOND));
		calendar.set(Calendar.MILLISECOND, calendar.getMaximum(Calendar.MILLISECOND));
		return convertDate2String(DEFAILT_DATE_TIME_PATTERN, calendar.getTime());
	}

	/**
	 * 获取日期最大的时间
	 * 
	 * @return
	 */
	public static Date getMaxDateTimeForToDay(Date date) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		calendar.set(Calendar.HOUR_OF_DAY,
				calendar.getMaximum(Calendar.HOUR_OF_DAY));
		calendar.set(Calendar.MINUTE, calendar.getMaximum(Calendar.MINUTE));
		calendar.set(Calendar.SECOND, calendar.getMaximum(Calendar.SECOND));
		calendar.set(Calendar.MILLISECOND, calendar.getMaximum(Calendar.MILLISECOND));
		return calendar.getTime();
	}

	/**
	 * 获取今天最小时间
	 * 
	 * @return
	 */
	public static String getMinDateTimeForToDay() {
		Calendar calendar = Calendar.getInstance();
		calendar.set(Calendar.HOUR_OF_DAY,
				calendar.getMinimum(Calendar.HOUR_OF_DAY));
		calendar.set(Calendar.MINUTE, calendar.getMinimum(Calendar.MINUTE));
		calendar.set(Calendar.SECOND, calendar.getMinimum(Calendar.SECOND));
		calendar.set(Calendar.MILLISECOND, calendar.getMinimum(Calendar.MILLISECOND));
		return convertDate2String(DEFAILT_DATE_TIME_PATTERN, calendar.getTime());
	}

	/**
	 * 获取 date 最小时间
	 * 
	 * @return
	 */
	public static Date getMinDateTimeForToDay(Date date) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		calendar.set(Calendar.HOUR_OF_DAY,
				calendar.getMinimum(Calendar.HOUR_OF_DAY));
		calendar.set(Calendar.MINUTE, calendar.getMinimum(Calendar.MINUTE));
		calendar.set(Calendar.SECOND, calendar.getMinimum(Calendar.SECOND));
		calendar.set(Calendar.MILLISECOND, calendar.getMinimum(Calendar.MILLISECOND));
		return calendar.getTime();
	}

	/**
	 * 获取发生日期的结束时间 根据用户设置的日期天数来判定这这个日期是什么(例如 (getHappenMinDate = 2008-10-1) 的话
	 * 那么 (getHappenMaxDate = 2008-11-1) 号)
	 * 
	 * @return
	 */
	public static Date getHappenMaxDate() {
		Calendar calendar = Calendar.getInstance();
		calendar.set(Calendar.DATE, calendar.getActualMaximum(Calendar.DATE));
		return calendar.getTime();
	}

	/**
	 * 加减天数
	 * 
	 * @param num 如果加则是正数，减则是负数
	 * @param Date
	 * @return
	 */
	public static Date addDay(int num, Date date) {
		return add(num, date, Calendar.DATE);
	}
	/**
	 * 加减分钟数
	 * 
	 * @param num 如果加则是正数，减则是负数
	 * @param Date
	 * @return
	 */
	public static Date addMinute(int num, Date date) {
		return add(num, date, Calendar.MINUTE);
	}
	/**
	 * 加减小时数
	 * 
	 * @param num 如果加则是正数，减则是负数
	 * @param Date
	 * @return
	 */
	public static Date addHour(int num, Date date) {
		return add(num, date, Calendar.HOUR);
	}
	/**
	 * 加减月数
	 * 
	 * @param num 如果加则是正数，减则是负数
	 * @param Date
	 * @return
	 */
	public static Date addMonth(int num, Date date){
		return add(num, date, Calendar.MONTH);
	}
	/**
	 * 加减年数
	 * 
	 * @param num 如果加则是正数，减则是负数
	 * @param Date
	 * @return
	 */
	public static Date addYear(int num, Date date){
		return add(num, date, Calendar.YEAR);
	}
	/**
	 * @param num 要添加或者减去的数值
	 * @param date 添加之前的日期
	 * @param calendar Calendar的字段
	 * @return
	 * */
	public static Date add(int num, Date date, int calendar){
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		cal.add(calendar, num);
		return cal.getTime(); 
	}

	/*
	 * public static void main(String[] args) {
	 * System.out.println(getMaxDateTimeForToDay());
	 * System.out.println(getMinDateTimeForToDay()); }
	 */

	/**
	 * 计算两端时间的小时差
	 * 
	 * @param begin
	 * @param end
	 * @return
	 */
	public static int getHour(Date begin, Date end) {
		Calendar c1 = Calendar.getInstance();
		c1.setTime(begin);
		Calendar c2 = Calendar.getInstance();
		c2.setTime(end);
		Long millisecond = c2.getTimeInMillis() - c1.getTimeInMillis();
		Long hour = millisecond / 1000 / 60 / 60;
		Long minute = (millisecond / 1000 / 60) % 60;
		if (minute >= 30) {
			hour++;
		}

		return hour.intValue();
	}

	/**
	 * 格式化日期
	 */
	public static String dateFormat(Date date) {
		if (date == null) {
			return null;
		}
		return DateFormat.getDateInstance().format(date);
	}

	/**
	 * @see 取得指定时间的给定格式()
	 * @return String
	 * @throws ParseException
	 */
	public static String setDateFormat(Date myDate, String strFormat)
			throws ParseException {
		if (myDate == null) {
			return null;
		}
		SimpleDateFormat sdf = new SimpleDateFormat(strFormat);
		String sDate = sdf.format(myDate);
		return sDate;
	}

	public static String setDateFormat(String myDate, String strFormat)
			throws ParseException {
		SimpleDateFormat sdf = new SimpleDateFormat(strFormat);
		String sDate = sdf.format(myDate);

		return sDate;
	}

	/*****************************************
	 * @功能 计算某年某月的结束日期
	 * @return interger
	 * @throws ParseException
	 ****************************************/
	public static String getYearMonthEndDay(int yearNum, int monthNum)
			throws ParseException {

		// 分别取得当前日期的年、月、日
		String tempYear = Integer.toString(yearNum);
		String tempMonth = Integer.toString(monthNum);
		String tempDay = "31";
		if (tempMonth.equals("1") || tempMonth.equals("3")
				|| tempMonth.equals("5") || tempMonth.equals("7")
				|| tempMonth.equals("8") || tempMonth.equals("10")
				|| tempMonth.equals("12")) {
			tempDay = "31";
		}
		if (tempMonth.equals("4") || tempMonth.equals("6")
				|| tempMonth.equals("9") || tempMonth.equals("11")) {
			tempDay = "30";
		}
		if (tempMonth.equals("2")) {
			if (isLeapYear(yearNum)) {
				tempDay = "29";
			} else {
				tempDay = "28";
			}
		}
		String tempDate = tempYear + "-" + tempMonth + "-" + tempDay;
		return tempDate;// setDateFormat(tempDate,"yyyy-MM-dd");
	}

	/*****************************************
	 * @功能 判断某年是否为闰年
	 * @return boolean
	 * @throws ParseException
	 ****************************************/
	public static boolean isLeapYear(int yearNum) {
		boolean isLeep = false;
		/** 判断是否为闰年，赋值给一标识符flag */
		if ((yearNum % 4 == 0) && (yearNum % 100 != 0)) {
			isLeep = true;
		} else if (yearNum % 400 == 0) {
			isLeep = true;
		} else {
			isLeep = false;
		}
		return isLeep;
	}

	/**
	 * 格式化日期
	 * 
	 * @throws ParseException
	 * 
	 *             例: DateUtils.formatDate("yyyy-MM-dd HH",new Date())
	 *             "yyyy-MM-dd HH:00:00"
	 */
	public static Date formatDate(String formatString, Date date)
			throws ParseException {
		if (date == null) {
			date = new Date();
		}
		if (org.apache.commons.lang.StringUtils.isBlank(formatString))
			formatString = DateUtils.DEFAILT_DATE_PATTERN;

		date = DateUtils.convertString2Date(formatString,
				DateUtils.convertDate2String(formatString, date));

		return date;
	}

	/**
	 * 格式化日期 yyyy-MM-dd
	 * 
	 * @throws ParseException
	 *             例： DateUtils.formatDate(new Date()) "yyyy-MM-dd 00:00:00"
	 */
	public static Date formatDate(Date date) throws ParseException {
		date = formatDate(DateUtils.DEFAILT_DATE_PATTERN, date);
		return date;
	}

	/**
	 * @throws ParseException
	 *             根据日期获得 星期一的日期
	 * 
	 */
	public static Date getMonDay(Date date) throws ParseException {

		Calendar cal = Calendar.getInstance();
		if (date == null)
			date = new Date();
		cal.setTime(date);
		if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY)
			cal.add(Calendar.WEEK_OF_YEAR, -1);

		cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);

		date = formatDate(cal.getTime());

		return date;
	}

	/**
	 * @throws ParseException
	 *             根据日期获得 星期日 的日期
	 * 
	 */
	public static Date getSunDay(Date date) throws ParseException {

		Calendar cal = Calendar.getInstance();
		if (date == null)
			date = new Date();
		cal.setTime(date);
		if (cal.get(Calendar.DAY_OF_WEEK) != Calendar.SUNDAY)
			cal.add(Calendar.WEEK_OF_YEAR, 1);

		cal.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);

		date = formatDate(cal.getTime());
		return date;
	}

	/**
	 * 获得 下个月的第一天
	 * 
	 * @param date
	 * @return
	 * @throws ParseException
	 */
	public static Date getNextDay(Date date) throws ParseException {
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		cal.add(Calendar.MONTH, 1);
		cal.set(Calendar.DATE, 1);
		return formatDate(cal.getTime());
	}

	/**
	 * 作者：张雨
	 * 
	 * @param Date
	 *            d（待比较的时间）
	 * @param Date
	 *            d1 (基准的时间-----一般是当前日期)
	 * @param int tian (本月内的指定的天数)
	 * @param int riqi（次月几号之前包括该日）
	 * 
	 * @return true or false (表示有权限或无权限)
	 * 
	 *         根据一月中的限定天数，和下个月的限制日期,返回true和false; 第一个参数待比较的日期，第二个参数是比较的基准,
	 *         例如：工作量分解里边的审核权限，这样判断今日是否有对某条记录的审核权限,
	 *         (本月的记录，本月在7天内可以审核，如果是上个月的记录那这个月的2号之后就不可以审核了，
	 *         如：2009-01-02的记录在2009-01-08之后就不可以审核了（也就是说周一添的周日过后就不可以审核），（如：例1）
	 *         2009-01-28的记录在2009-02-02可以审核，在2009-02-03以及之后就不可以审核了，（如：例2）)
	 * 
	 *         方法示例： 例1： Date d = new Date(109,0,2); Date d1 = new
	 *         Date(109,0,8); Boolean r = this.isDatePower(d,d1,7,2); 结果为true
	 * 
	 *         Date d = new Date(109,0,2); Date d1 = new Date(109,0,9); Boolean
	 *         r = this.isDatePower(d,d1,7,2); 结果为false
	 * 
	 *         例2: Date d = new Date(109,0,28); Date d1 = new Date(109,1,2);
	 *         Boolean r = this.isDatePower(d,d1,7,2); 结果为true
	 * 
	 *         Date d = new Date(109,0,28); Date d1 = new Date(109,1,3); Boolean
	 *         r = this.isDatePower(d,d1,7,2); 结果为false 这里的参数天是包括当天，日期也是包括当日
	 */
	public static Boolean isDatePower(Date d, Date d1, int tian, int riqi) {

		// 一般审核都是添加记录之后，所以先比较待比较日期是否是在当日之前
		Boolean isBefor = d.before(d1);
		if (isBefor) {
			// 把两个日期的时分秒去掉
			d = new Date(d.getYear(), d.getMonth(), d.getDate());
			d1 = new Date(d1.getYear(), d1.getMonth(), d1.getDate());

			// 看两日期相距的天数
			int tianShu = DateUtils.bTDays(d, d1);
			// 相隔的天数小于指定的天，则就说明是在指定天数之内
			if (tianShu < tian) {
				// 如果在同一个月的话，有权限
				if (d.getMonth() == d1.getMonth()) {
					return true;
				} else {
					// 如果不在同一个月也就是出现跨月情况，那看当前日期是不是在指定日期之前
					if (d1.getDate() <= riqi) {
						return true;
					} else {
						// 不在指定日期之前没权限
						return false;
					}
				}
			} else {
				// 相隔不在指定天数之内没权限
				return false;
			}
		} else {
			// 待比较日期在参照日期之后没权限
			return false;
		}

	}

	/**
	 * 作者：张雨
	 * 
	 * @param Date
	 *            d（基准日期——————一般是当前日期）
	 * @param int tian (本月内的指定的天数之前的日期，如果是七天内那就是说六天前)
	 * @param int riqi（次月几号之前包括该日）
	 * 
	 * @return Date型数据(返加一个最小日期型的数据)表示最早可操作那天的记录（返回那天的日期）
	 * 
	 *         日期型参数是一个基准
	 *         例如：工作量分解里边的添加的日期权限限制，每月二号之后就不可以添加上月的工作量，本月中可以添加带今天往前七天内的工作量
	 *         (及最小的日期就是六天前)
	 *         (如：2009-01-08可以添加2009-01-02到2009-01-08这段日期内的工作量（如：例1）
	 *         2009-02-02可以添加2009-01-27到2009-02-02的工作量记录（如：例2）)
	 *         2009-02-03到2009-02-06则最前可以添加2009-02-01的工作量记录（如：例3）)
	 * 
	 *         方法示例： 例1： Date d = new Date(109,0,8); Date d1 =
	 *         this.minDatePower(d,7,2); 结果为2009-01-02
	 * 
	 *         例2: Date d = new Date(109,1,2); Date r =
	 *         this.minDatePower(d,7,2); 结果为2009-01-27
	 * 
	 *         例3: Date d = new Date(109,1,3); Date r =
	 *         this.minDatePower(d,7,2); 结果为2009-02-01
	 * 
	 *         Date d = new Date(109,1,6); Date r = this.minDatePower(d,7,2);
	 *         结果为2009-02-01 这里的参数天是包括当天，日期也是包括当日
	 */
	public static Date minDatePower(Date d, int tian, int riqi) {

		// 把这个时间截成整时间把分秒时都去掉
		d = new Date(d.getYear(), d.getMonth(), d.getDate());

		// 一个要返回的日期
		Date date1 = null;

		// 如果规定是：可以添加以基准日期为准往前的七天内的工作记录，且下个月二号之号就不可添加上月的记录，那就是二号之前或六号之后返加六天前日期(正好带当天是七天内)，否则返加当月第一天。
		if (!(d.getDate() > riqi && d.getDate() < tian)) {
			// 得到六天前的日期
			date1 = DateUtils.plusDateC(d, -(tian - 1));
		} else {
			// 如果到指定日期之后，最小只能返回这个月的第一天这个日期
			date1 = new Date(d.getYear(), d.getMonth(), 1);
		}
		return date1;

	}

	/**
	 * 作者：张雨
	 * 
	 * @param Date
	 *            d（待比较的时间）
	 * 
	 * @param Date
	 *            d1（基准日期------一般是当前日期 ）
	 * 
	 * @param int riqi（次月几号之前包括该日）
	 * 
	 * @return true or false (表示有权限或无权限)
	 * 
	 *         例如：工作量分解里边删除和修改的时间权限限制 (本月的记录，本月本月有权限删除和修改，（下个月到2号之后就不可以再进行删除和修改）
	 *         如：2009-01-02的记录在2009-01-02到2009-02-02这段时间可以修改和删除，
	 *         而2009-02-02之后就不可删除和修改了（如：例1）
	 * 
	 *         方法示例： 例1： Date d = new Date(109,0,2); Date d1 = new
	 *         Date(109,0,8); Boolean r = this.updatePower(d,d1,2); 结果为true
	 * 
	 *         Date d = new Date(109,0,2); Date d1 = new Date(109,1,2); Boolean
	 *         r = this.updatePower(d,d1,2); 结果为true
	 * 
	 *         Date d = new Date(109,0,2); Date d1 = new Date(109,1,3); Boolean
	 *         r = this.updatePower(d,d1,2); 结果为false
	 * 
	 *         日期也是包括当日
	 */
	public static boolean updatePower(Date date1, Date date2, int riqi)
			throws Exception {
		Date upDelNowDate = date2;

		// 发生日期在当前日期之前才可以有权限
		if (date1.before(upDelNowDate)) {

			// 如果在本月内有权限
			if (date1.getMonth() == upDelNowDate.getMonth()
					&& date1.getYear() == upDelNowDate.getYear()) {
				return true;
			} else {
				// 得到两个日期当月的有第一天（用于判断是不是上一个月）
				date1 = new Date(date1.getYear(), date1.getMonth(), 1);
				date2 = new Date(date2.getYear(), date2.getMonth(), 1);

				// 当基日期往前推一个月看是不是那个待比较的日期
				date2 = DateUtils.plusMonthC(date2, -1);
				// 是上一个月时
				if (date2.getTime() == date1.getTime()) {
					// 在指定的日期后没权限
					if (upDelNowDate.getDate() > riqi) {
						return false;
					}
					return true;
				} else {
					// 不是上一个月没权限
					return false;
				}
			}
		} else {
			// 发生日期在当前日期之后没有权限
			return false;
		}
	}

	/**
	 * 得到两个时间相差的小时数，不够一小时的按相差小时数是0 时间格式必须是yyyy-MM-dd HH:mm:ss 形式，返回的小时数不准确
	 * startDate必须在endDate之前，否则返回0
	 * */
	public static int betweenHouse(Date startDate, Date endDate)
			throws Exception {
		int house = 0;
		// 判断时间的先后顺序
		if (startDate.after(endDate))
			return house;
		// 得到两个时间中一天内的小时
		int shouse = startDate.getHours();
		int ehouse = endDate.getHours();
		// 得到两个时间相差的天数
		int day = bTDays(formatDate((Date) startDate.clone()),
				formatDate((Date) endDate.clone()));
		// 判断是否相差是一天
		if (day > 1)
			house += (day - 1) * 24;// 如果两个时间相差大小一天加上24小时
		// endDate时间里时刻钟是否大于startDate时刻钟
		if ((ehouse - shouse) >= 0) {
			if (day > 0)// 如果相差的天数大于一天则加上24个小时
				house += 24;
			if ((ehouse - shouse) > 1)// 如果时刻钟相差大于一个小时则加上相应的时刻钟
				house = house + (ehouse - shouse);
		} else {
			if (day > 0)// 如果相差的天数大于0则加上相应的时刻钟
				house = house + (24 - ehouse) + shouse;
		}
		// 判断两个时候钟是否相差一个小时
		if ((ehouse - shouse) > 0) {
			int sministand = startDate.getMinutes();
			int eministand = endDate.getMinutes();
			// 如果相差一个小时，后面的分钟数大于前面的分钟数则加一个小时，否则不计为一个小时
			if (eministand > sministand)
				house++;
		}
		return house;
	}

	/**
	 * 作者：张雨
	 * 
	 * @param Date
	 *            d(要操作的Date对象)
	 * @param int i (要推的天数)
	 * 
	 * @return Date 指定的日期i天前（后）的日期
	 * 
	 *         往前或后推几日(正数往前，负数往后)
	 */
	public static Date plusDateC(Date d, int i) {
		DateTime dt = new DateTime(d);
		dt = dt.plusDays(i);
		return dt.toDate();
	}

	/**
	 * 作者：张雨
	 * 
	 * @param Date
	 *            d(要操作的Date对象)
	 * @param int i (要推的月数)
	 * 
	 * @return Date 指定的日期i月前（后）的日期
	 * 
	 *         往前或后推月(正数往前，负数往后)
	 */
	public static Date plusMonthC(Date d, int i) {
		DateTime dt = new DateTime(d);
		dt = dt.plusMonths(i);
		return dt.toDate();
	}

	/**
	 * 作者：张雨
	 * 
	 * @param Date
	 *            d(要操作的Date对象)
	 * @param int i (要推的年数)
	 * 
	 * @return Date 指定的日期i年前（后）的日期
	 * 
	 *         往前或后推年(正数往前，负数往后)
	 */
	public static Date plusYearC(Date d, int i) {
		DateTime dt = new DateTime(d);
		dt = dt.plusYears(i);
		return dt.toDate();
	}

	/**
	 * 作者：张雨
	 * 
	 * @param Date
	 *            d(要操作的Date对象)
	 * @param int i (要推的小时数)
	 * 
	 * @return Date 指定的日期i小时前（后）的日期
	 * 
	 *         往前或后推小时(正数往前，负数往后)
	 */
	public static Date plusHourC(Date d, int i) {
		DateTime dt = new DateTime(d);
		dt = dt.plusHours(i);
		return dt.toDate();
	}

	/**
	 * 作者：张雨
	 * 
	 * @param Date
	 *            d(要操作的Date对象)
	 * @param int i (要推的分钟数)
	 * 
	 * @return Date 指定的日期i分钟前（后）的日期
	 * 
	 *         往前或后推分钟(正数往前，负数往后)
	 */
	public static Date plusMinuteC(Date d, int i) {
		DateTime dt = new DateTime(d);
		dt = dt.plusMinutes(i);
		return dt.toDate();
	}

	/**
	 * 作者：张雨
	 * 
	 * @param Date
	 *            d(要操作的Date对象)
	 * @param int i (要推的周数)
	 * 
	 * @return Date 指定的日期i周前（后）的日期
	 * 
	 *         往前或后推周(正数往前，负数往后)
	 */
	public static Date plusWeekC(Date d, int i) {
		DateTime dt = new DateTime(d);
		dt = dt.plusWeeks(i);
		return dt.toDate();
	}

	/**
	 * 作者：张雨
	 * 
	 * @param Date
	 *            d
	 * @param Date
	 *            d1
	 * 
	 * @return int 两个日期相隔的天数
	 * 
	 *         注意：这种方法返回的效果可能不是很理想，因为它们的原理是两个日期相减得到毫秒数，然后根据毫秒数再转成年、月、日、周等、
	 * 
	 *         比较两个时间相差的天数(第一个日期小于第二日期返回正数，第一个日期大于第二个日期返回负数)
	 */
	public static int bTDays(Date d, Date d1) {
		DateTime dt = new DateTime(d);
		DateTime dt1 = new DateTime(d1);
		Days dS = Days.daysBetween(dt, dt1);
		int kd = dS.getDays();
		return kd;
	}

	/**
	 * 作者：张雨
	 * 
	 * @param Date
	 *            d
	 * @param Date
	 *            d1
	 * 
	 * @return int 两个日期相隔的月数
	 * 
	 *         注意：这种方法返回的效果可能不是很理想，因为它们的原理是两个日期相减得到毫秒数，然后根据毫秒数再转成年、月、日、周等、
	 * 
	 *         比较两个时间相差的月数(第一个日期小于第二日期返回正数，第一个日期大于第二个日期返回负数)
	 */
	public static int bTMonths(Date d, Date d1) {
		DateTime dt = new DateTime(d);
		DateTime dt1 = new DateTime(d1);
		Months dS = Months.monthsBetween(dt, dt1);
		int kd = dS.getMonths();
		return kd;
	}

	/**
	 * 作者：张雨
	 * 
	 * @param Date
	 *            d
	 * @param Date
	 *            d1
	 * 
	 * @return int 两个日期相隔的年数
	 * 
	 *         注意：这种方法返回的效果可能不是很理想，因为它们的原理是两个日期相减得到毫秒数，然后根据毫秒数再转成年、月、日、周等、
	 * 
	 *         比较两个时间相差的年数(第一个日期小于第二日期返回正数，第一个日期大于第二个日期返回负数)
	 */
	public static int bTYears(Date d, Date d1) {
		DateTime dt = new DateTime(d);
		DateTime dt1 = new DateTime(d1);
		Years dS = Years.yearsBetween(dt, dt1);
		int kd = dS.getYears();
		return kd;
	}

	/**
	 * 作者：张雨
	 * 
	 * @param Date
	 *            d
	 * @param Date
	 *            d1
	 * 
	 * @return int 两个日期相隔的小时数
	 * 
	 *         注意：这种方法返回的效果可能不是很理想，因为它们的原理是两个日期相减得到毫秒数，然后根据毫秒数再转成年、月、日、周等、
	 * 
	 *         比较两个时间相差的小时数(第一个日期小于第二日期返回正数，第一个日期大于第二个日期返回负数)
	 */
	public static int bTHours(Date d, Date d1) {
		DateTime dt = new DateTime(d);
		DateTime dt1 = new DateTime(d1);
		Hours dS = Hours.hoursBetween(dt, dt1);
		int kd = dS.getHours();
		return kd;
	}

	/**
	 * 作者：张雨
	 * 
	 * @param Date
	 *            d
	 * @param Date
	 *            d1
	 * 
	 * @return int 两个日期相隔的分钟数
	 * 
	 *         注意：这种方法返回的效果可能不是很理想，因为它们的原理是两个日期相减得到毫秒数，然后根据毫秒数再转成年、月、日、周等、
	 * 
	 *         比较两个时间相差的分钟数(第一个日期小于第二日期返回正数，第一个日期大于第二个日期返回负数)
	 */
	public static int bTMinutes(Date d, Date d1) {
		DateTime dt = new DateTime(d);
		DateTime dt1 = new DateTime(d1);
		Minutes dS = Minutes.minutesBetween(dt, dt1);
		int kd = dS.getMinutes();
		return kd;
	}

	/**
	 * 作者：张雨
	 * 
	 * @param Date
	 *            d
	 * @param Date
	 *            d1
	 * 
	 * @return int 两个日期相隔的周数
	 * 
	 *         注意：这种方法返回的效果可能不是很理想，因为它们的原理是两个日期相减得到毫秒数，然后根据毫秒数再转成年、月、日、周等、
	 * 
	 *         比较两个时间相差的周数(第一个日期小于第二日期返回正数，第一个日期大于第二个日期返回负数)
	 */
	public static int bTWeeks(Date d, Date d1) {
		DateTime dt = new DateTime(d);
		DateTime dt1 = new DateTime(d1);
		Weeks dS = Weeks.weeksBetween(dt, dt1);
		int kd = dS.getWeeks();
		return kd;
	}

	/**
	 * @author zhangyu 指定日期上一月第一天0点
	 * @throws ParseException
	 */
	public static Date getBeforeMonthFirstDay(Date date) throws Exception {
		return DateUtils.convertString2Date(DateUtils.convertDate2String(
				"yyyy-MM", DateUtils.plusMonthC(date, -1)) + "-01");
	}

	/**
	 * 
	 * @author zhangyu 指定日期上一月第一天0点
	 * @throws ParseException
	 *             格式：yyyy-MM-dd
	 */
	public static String getBeforeMonthFirstDayString(Date date)
			throws Exception {

		return DateUtils.convertDate2String("yyyy-MM",
				DateUtils.plusMonthC(date, -1))
				+ "-01";
	}

	/**
	 * @author zhangyu 指定日期上一月最后一天0点
	 * @throws ParseException
	 */
	public static Date getBeforeMonthMaxDay(Date date) throws Exception {
		Date rtn = getMonthFirstDay(date);
		return DateUtils.plusDateC(rtn, -1);
	}

	/**
	 * 
	 * @author zhangyu 指定日期上一月最后一天0点
	 * @throws ParseException
	 *             格式：yyyy-MM-dd
	 */
	public static String getBeforeMonthMaxDayString(Date date) throws Exception {
		Date rtn = DateUtils.plusDateC(getMonthFirstDay(date), -1);
		return DateUtils.convertDate2String("yyyy-MM-dd", rtn);
	}

	/**
	 * @author zhangyu 指定日期对应月第一天0点
	 * @throws ParseException
	 */
	public static Date getMonthFirstDay(Date date) throws Exception {
		return DateUtils.convertString2Date(DateUtils.convertDate2String(
				"yyyy-MM", date) + "-01");
	}

	/**
	 * 
	 * @author zhangyu 指定日期对应月第一天0点
	 * @throws ParseException
	 *             格式：yyyy-MM-dd
	 */
	public static String getMonthFirstDayString(Date date) throws Exception {
		return DateUtils.convertDate2String("yyyy-MM", date) + "-01";
	}

	/**
	 * @author zhangyu 指定日期对应月最后一天0点
	 * @throws ParseException
	 */
	public static Date getMonthMaxDay(Date date) throws Exception {
		Date rtn = getNextMonthFirstDay(date);
		return DateUtils.plusDateC(rtn, -1);
	}

	/**
	 * 
	 * @author zhangyu 指定日期对应月最后一天0点
	 * @throws ParseException
	 *             格式：yyyy-MM-dd
	 */
	public static String getMonthMaxDayString(Date date) throws Exception {
		Date rtn = DateUtils.plusDateC(getNextMonthFirstDay(date), -1);
		return DateUtils.convertDate2String(rtn);
	}

	/**
	 * @author zhangyu 指定日期对应月下月第一天0点
	 * @throws ParseException
	 */
	public static Date getNextMonthFirstDay(Date date) throws Exception {
		return DateUtils.convertString2Date(DateUtils.convertDate2String(
				"yyyy-MM", DateUtils.plusMonthC(date, 1)) + "-01");
	}

	/**
	 * @author zhangyu 指定日期对应月下月第一天0点
	 * @throws ParseException
	 *             格式：yyyy-MM-dd
	 */
	public static String getNextMonthFirstDayString(Date date) throws Exception {
		return DateUtils.convertDate2String("yyyy-MM",
				DateUtils.plusMonthC(date, 1))
				+ "-01";
	}

	/**
	 * @author zhangyu 指定日期下月最后一天0点
	 * @throws ParseException
	 */
	public static Date getNextMonthMaxDay(Date date) throws Exception {
		Date rtn = DateUtils.plusMonthC(getNextMonthFirstDay(date), 1);
		return DateUtils.plusDateC(rtn, -1);
	}

	/**
	 * 
	 * @author zhangyu 指定日期下月最后一天0点
	 * @throws ParseException
	 *             格式：yyyy-MM-dd
	 */
	public static String getNextMonthMaxDayString(Date date) throws Exception {
		Date rtn = DateUtils.plusDateC(
				DateUtils.plusMonthC(getNextMonthFirstDay(date), 1), -1);
		return DateUtils.convertDate2String("yyyy-MM-dd", rtn);
	}

	public static void main(String[] args) {

		try {
			System.out.println(DateUtils.formatDate(new Date()));
			System.out.println(DateUtils
					.formatDate("yyyy-MM-dd HH", new Date()));
		} catch (Exception e) {

		}

		Date date = new Date();
		try {
			System.out.println("本月第一天日期："
					+ DateUtils.getMonthFirstDayString(date));
			System.out.println("本月第一天日期："
					+ DateUtils.getMonthFirstDay(date).toString());
			System.out.println("本月最后一天日期："
					+ DateUtils.getMonthMaxDayString(date));
			System.out.println("本月最后一天日期："
					+ DateUtils.getMonthMaxDay(date).toString());
			System.out.println("上月第一天日期："
					+ DateUtils.getBeforeMonthFirstDay(date).toString());
			System.out.println("上月第一天日期："
					+ DateUtils.getBeforeMonthFirstDayString(date).toString());
			System.out.println("上月最后一天日期："
					+ DateUtils.getBeforeMonthMaxDay(date).toString());
			System.out.println("上月最后一天日期："
					+ DateUtils.getBeforeMonthMaxDayString(date).toString());
			System.out.println("下月第一天日期："
					+ DateUtils.getNextMonthFirstDay(date).toString());
			System.out.println("下月第一天日期："
					+ DateUtils.getNextMonthFirstDayString(date).toString());
			System.out.println("下月最后一天日期："
					+ DateUtils.getNextMonthMaxDay(date).toString());
			System.out.println("下月最后一天日期："
					+ DateUtils.getNextMonthMaxDayString(date).toString());
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	/**
	 * 比较两个字符串表示的日期相差多少天 日期格式必须是“yyyy-MM-dd”
	 * 
	 * @param String
	 *            start
	 * @param String
	 *            end
	 * @throws ParseException
	 */
	public static Long getBetweenDays(String start, String end)
			throws ParseException {
		SimpleDateFormat sfA = new SimpleDateFormat("yyyy-MM-dd");
		SimpleDateFormat sfB = new SimpleDateFormat("yyyy-MM-dd");
		Date a = sfA.parse(start);
		Date b = sfB.parse(end);
		Long dayS = 0L;
		if (a.before(b)) {
			dayS = (b.getTime() + (1000 * 60 * 60 * 24 - 1) - a.getTime())
					/ (1000 * 60 * 60 * 24);
		} else {
			dayS = (a.getTime() + (1000 * 60 * 60 * 24 - 1) - b.getTime())
					/ (1000 * 60 * 60 * 24);
		}

		if (dayS < 0) {
			dayS = dayS * (-1);
		}
		return dayS;
	}

	/**
	 * 比较一个字符串表示的日期和"1799-12-31"之间相差多少天 日期格式必须是“yyyy-MM-dd”
	 * 
	 * @param String
	 *            start
	 * @param String
	 *            end
	 * @throws ParseException
	 */
	public static Long getBetweenDays(String start) throws ParseException {
		return DateUtils.getBetweenDays(start, "1899-12-30");
	}
}
